package com.navinfo.platform.trip.common.arithmetic;

import com.navinfo.platform.trip.common.arithmetic.data.CommonData;
import com.navinfo.platform.trip.common.arithmetic.data.OuterStatisticData;
import com.navinfo.platform.trip.common.arithmetic.var.VarSharpTurning_DFN;
import com.navinfo.platform.trip.common.arithmetic.manager.AbstractArithmetic;
import com.navinfo.platform.trip.common.config.ConfigMap;

/**
 * 东风新版，急转弯算法<br/>
     * 1.车速>60 km/h；<br/>
     * 2.计算GPS转向速度 W={Ri -（Ri-1）}/ T【Ri为每一秒的 GPS 转角数值，T为持续时间】<br/>
     * 3.判断W＞30°， 判断持续时间 T>3 秒，识别为一次急转弯事件；<br/>
     * 4.当持续时间 T 小于等于 2 秒，中间 1 秒 W<30°，再持续 2 秒 W＞30°，视为同一次事件；<br/>
 * 输出：统计<br/>
 * @author web
 */
public class SharpTurning_DFN extends AbstractArithmetic<VarSharpTurning_DFN> {
    /**
     * 速度阀值，单位：km/h，默认60
     */
    private Integer speedThreshold = ConfigMap.getInteger("DFN_ST_Speed_Threshold");
    /**
     * 方向差阀值，单位：度，默认30
     */
    private Integer directionThreshold = ConfigMap.getInteger("DFN_ST_Direction_Threshold");
    /**
     * 时间阈值，单位：ms，默认3000
     */
    private Integer durationThreshold = ConfigMap.getInteger("DFN_ST_Duration_Threshold");

    /**
     * 两点间的转向角差，取小于180度的值
     */
    private int dffDirection(CommonData commonData) {
        int dffDirection = Math.abs(commonData.getGpsDirection() - commonData.getLastGpsDirection());
        return dffDirection>180 ? 360-dffDirection : dffDirection;
    }

    @Override
    public void calculate() {
        logger.debug("进入东风新版急转弯算法...");
        VarSharpTurning_DFN var = getObj();
        CommonData commonData = getCommonData();
        long duration = var.getDuration() + commonData.getDffTime();

        //速度小于等于阀值，结束急转弯判断
        if (commonData.getSpeedKmh()<=speedThreshold || duration<=0) {
            var.reset();
            return;
        }

        //设置持续时长
        var.setDuration(duration);

        //速度大于阀值，进行急转弯判断，取最后一个急转弯的索引
        int[] statusArr = var.getStatusArr();
        int lastIndex = -1;
        for (int i=0; i<statusArr.length; i++) {
            if (1==statusArr[i]) {
                lastIndex = i;
            }
        }

        //暂没考虑算法的第四个条件[1,1,0,1,1]
        int dffDi = dffDirection(commonData);
        if (-1==lastIndex || 0==lastIndex || 1==lastIndex) {
            if(dffDi/(var.getDuration()/1000) > directionThreshold){
                statusArr[lastIndex+1] = 1;
            }else{
                var.reset();
            }
        } else if (2 == lastIndex) {
            //生成急转弯事件
            if (dffDi/(var.getDuration()/1000) > directionThreshold) {
                var.addNumber(1);
            }

            var.reset();
        } else {
            //生成急转弯事件
            var.addNumber(1);
            var.reset();
        }

        logger.debug("离开东风新版急转弯算法...");
    }

    @Override
    public void collect(OuterStatisticData statisticDataOut) {
        statisticDataOut.setSharpTurningNumber_DFN(getObj().getNumber());
    }
}
